/**
 * @file   Vector.h
 * @author Linfufu
 * @date   Sun Oct 17 16:28:06 2021
 * 
 * @brief  
 * 
 * 
 */


#include<algorithm>

template <typename Object>
class Vector{
public://用户指定初始大小，默认值为零
  explicit Vector( int initSize = 0) : theSize(initSize ),theCapacity( initSize + SPARE_CAPACITY){
    objects = new Object[ theCapacity ];
  };
  //复制构造函数，生成一个新的Vector 
  Vector( const Vector & rhs ) : theSize{ rhs.theSize },theCapacity{ rhs.theCapacity }, objects { nullptr }{
      objects = new Object[ theCapacity ];
      for( int k=0; k < theSize; ++k )
	objects[k] = rhs.objcts[k];
    };
    //上述Vector 由operator=来非正式实现，采用swap交换
    Vector & operator= (const Vector & rhs){
      Vector copy = rhs;
      std::swap( *this, copy );
      return *this;
    };

  ~Vector(){
    delete [] objects;
  };//析构函数，清除内存空间

  Vector( Vector && rhs ) : theSize{ rhs.theSize },
    theCapacity{ rhs.theCapacity }, objects{ rhs.objects }{
      rhs.objects = nullptr;
      rhs.theSize = 0;
      rhs.theCapacity = 0;
    };
    //通过移动来实现交换
    Vector & operator= (Vector && rhs ){
      std::swap( theSize, rhs.theSize );
      std::swap( theCapacity, rhs.theCapacity );
      std::swap( objects, rhs.objects );

      return *this;
    };
    //调整大小
    void resize( int newSize ){
      if( newSize > theCapacity )
	reserve( newSize * 2);
      theSize = newSize;
    };
    //收缩低层数组
    void reserve( int newCapacity){
      if( newCapacity < theSize )
	return;

      Object *newArray = new Object[ newCapacity ];//分配新数组
      for( int k = 0; k < theSize; ++k )
	newArray[ k ] = std::move( objects[k] );//移动旧内容

      theCapacity = newCapacity;
      std::swap( objects, newArray );
      delete [] newArray;//回收数组
    };
    //确保index在0到size()-1范围内，很容易添加错误检查，如不然，则抛出异常
    Object & operator[]( int index ){
      return objects[ index ];
    };
    const Object & operator[]( int index ) const{
      return objects[ index ];
    };
    //分别实现empty,size,Capacity,push_back,pop_back
    bool empty() const{
      return size() == 0;
    };
    int size() const{
      return theSize;
    };
    int capacity() const{
      return theCapacity;
    };

    void push_back(const Object & x){
      if( theSize == theCapacity )
	reserve( 2* theCapacity + 1 );
      objects[ theSize++ ] = x;
    };

    void push_back( Object && x ){
      if( theSize == theCapacity )
	reserve( 2 * theCapacity + 1 );
      objects[ theSize++ ] = std::move(x);
    };

    void pop_back(){
      --theSize;
    };

    const Object & back() const{
      return objects[ theSize - 1 ];
    };
    //声明嵌套型迭代器和const类型的迭代器
    typedef Object * iterator;
    typedef const Object * const_iterator;

    iterator begin(){
      return &objects[ 0 ];
    };
    const_iterator begin() const{
      return &objects[ 0 ];
    };
    iterator end(){
      return &objects[ size() ];
    };
    const_iterator end() const{
      return &objects[ size() ];
    };

    static const int SPARE_CAPACITY = 16;

 private:
    int theSize;
    int theCapacity;
    Object * objects;
    
};
